package main

import (
	"fmt"
)

func main() {
	//声明长度10的int数组，默认值为0
	var arr [10]int
	arr[0] = 1
	arr[1] = 2
	fmt.Printf("arr[0] = %d\n", arr[0])
	fmt.Printf("arr[9] = %d\n", arr[9])
	fmt.Println("arr =", arr)

	//简短声明
	arr2 := [5]int{1, 2, 3, 4, 5}
	fmt.Println(arr2)

	arr3 := [10]int{1, 2, 3, 4, 5} //后5个元素默认为0
	fmt.Println(arr3)

	arr4 := [...]int{1, 2, 3} //自动指定长度
	fmt.Println(arr4)

	arr5 := []int{1, 2, 3} //自动指定长度简化
	fmt.Println(arr5)

	//二维数组
	arr6 := [2][3]int{
		[3]int{1, 2, 3},
		[3]int{4, 5, 6},
	}
	fmt.Println(arr6[1][2])
	fmt.Println(arr6)

	//简化写法
	arr7 := [2][3]int{
		{1, 2, 3},
		{4, 5, 6},
	}
	fmt.Println(arr7)

	//简化写法，自动指定长度
	arr8 := [][]int{
		{1, 2, 3},
		{4, 5, 6},
	}
	fmt.Println(arr8)

	//声明动态数组（不是真正的动态数组，是一个引用类型）
	var slice []int
	fmt.Println(slice)
	//slice可重新引用新数组
	slice = []int{1, 2, 3}

	//数组切片
	var arr9 = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}

	var ar1, ar2 []byte //声明两个动态数组引用
	ar1 = arr9[0:5]     //切片含头不含尾，ar1引用arr9的前5个元素
	ar2 = arr9[5:10]    //ar1引用arr9的后5个元素
	fmt.Println(arr9)
	fmt.Println(ar1, ar2)
	fmt.Println(string(ar1), string(ar2))

	//由于切片是引用原数组，修改切片元素会导致原数组同时被修改
	ar1[0] = 'b'
	fmt.Println(arr9)

	//切片的简化操作
	var sl []byte
	sl = arr9[:3] //从头部切到3，相当于arr[0:3]
	fmt.Println(sl)
	sl = arr9[3:] //从3切到尾部，相当于arr[3:10]，即arr[3:len(arr)]
	fmt.Println(sl)
	sl = arr9[:] //完整切片，相当于arr[0:len(arr)]
	fmt.Println(sl)

	//数组内置函数
	sl = arr9[0:4]
	fmt.Printf("切片长度：%d\n", len(sl))
	fmt.Printf("切片最大容量：%d\n", cap(sl))
	//新版语法，指定最大容量(7-0=7)
	sl = arr9[0:4:7]
	fmt.Printf("切片长度：%d\n", len(sl))
	fmt.Printf("切片最大容量：%d\n", cap(sl))

	sl2 := append(sl, 'z') //向切片尾部添加元素
	fmt.Println(string(sl))
	fmt.Println(string(sl2))

	var sl3 []byte

	n := copy(sl3, sl2) //将sl2的元素复制到sl3，返回复制元素个数n
	fmt.Println(n)      //复制数量0？

}
